/**
 * Created by Administrator on 2017/2/20.
 */

var express = require('express');
var router = express.Router();

var AdminToken = require('../db/user_tokens.js');
var ManagementDao = require('../dao/admin_management');
var crypto = require('crypto');
var ManagementRouter = module.exports;
var Log = require('../dao/log.js');


/**
 * 系统管理员重设产品管理员、功能管理员密码；产品管理员重设功能管理员密码
 * @param  token     初始密码   account + llc
 * @param  uid  app
 *
 *         url/admin_management/resetPwd
 */
ManagementRouter.resetAdmPwd = function(req, res) {
    var par = paramAll(req);
    router.checkAdmin(par,function (err,errCode,handleAdmin,adminInfo) {

        if(err){
            res.json(new ERR(err, errCode));
            return;
        }

        if(!handleAdmin){
            res.json(new ERR('服务器异常', 400));
            return;
        }
        par.password = 'tao1024' + handleAdmin.account + 'llc';
        var md5=crypto.createHash('md5');
        md5.update(par.password);
        par.password = md5.digest('hex');
        ManagementDao.resetAdmPwd(par, function(err , data){
            var logInfo = {};
            logInfo.account = handleAdmin.account;
            logInfo.uid = par.uid;
            logInfo.adm_uid = adminInfo.uid;
            logInfo.type = 3;
            if(err) {
                logInfo.detail = err;
                Log.adminLog(logInfo,function (result) {
                    if(result){
                        res.json(new ERR(err, 400));
                    }
                });
            } else {
                logInfo.detail = '重置密码成功!';
                Log.adminLog(logInfo,function (result) {
                    if(result){
                        res.json(new PKG('重置成功！'));
                    }
                });
            }
        });

    });
}
router.post('/resetAdmPwd', ManagementRouter.resetAdmPwd);

/**
 * 管理员更改自己密码
 * @param  token
 *         url/admin_management/changePwd
 */
ManagementRouter.changePwd = function(req, res) {
    var par = paramAll(req);
    AdminToken.checkLogin(par.token, function (err, adminInfo) {
        if(err) {
            return;
        }
        if(!adminInfo){
            res.json(new ERR('请先登录', 403));
            return ;
        }
        if(!adminInfo.isAdmin) {
            res.json(new ERR('无权限', 400));
            return ;
        }
        if(!par.oldPassword){   // 需要判断密码对不对
            res.json(new ERR('oldPassword 不为空！', 400));
            return;
        }
        if(!par.password){
            res.json(new ERR('password 不为空！', 400));
            return;
        }
        par.uid = adminInfo.uid;
        par.password = 'tao1024' + par.password;
        var md5=crypto.createHash('md5');
        md5.update(par.password);
        par.password = md5.digest('hex');

        ManagementDao.changePwd(par, function(err , data){
            if(err) {
                res.json(new ERR(err, 400));
                return;
            }
            AdminToken.updateToToken(adminInfo, function(e, d) {
                logInfo = {};
                logInfo.adm_uid = adminInfo.uid;
                logInfo.type = 1;
                if(e) {
                    logInfo.detail = '修改密码失败！';
                    Log.adminLog(logInfo,function (result) {
                        if(result){
                            res.json(new ERR('更改密码失败！', 400));
                        }
                    });
                } else {
                    logInfo.detail = '修改密码成功！';
                    Log.adminLog(logInfo,function (result) {
                        if (result) {
                            adminInfo.token = d;
                            res.json(new PKG(adminInfo));
                        }
                    });
                }
            });

        });
    });
}
router.post('/changePwd', ManagementRouter.changePwd);

/**
 * 系统管理员添加产品管理员、功能管理员   初始密码   account + llc
 * 或产品管理员添加功能管理员  一次只能设置一个产品类的管理员，功能可以多个（app字段唯一）
 * @param  token
 *         url/admin_management/addAdmin
 */
ManagementRouter.addAdmin = function(req, res) {
    var par = paramAll(req);
    if(!par.token){
        res.json(new ERR('token 不为空！', 400));
        return;
    }
    if (!par.role) {
        res.json(new ERR('role 不为空！', 400));
        return;
    }
    if (!par.app_sid) {
        res.json(new ERR('app_sid 不为空！', 400));
        return;
    }
    if (!par.account) {
        res.json(new ERR('account 不为空！', 400));
        return;
    }
    AdminToken.checkLogin(par.token, function (err, adminInfo) {
        if (err) {
            return;
        }
        if (!adminInfo) {
            res.json(new ERR('请先登录', 403));
            return;
        }
        if (!adminInfo.isAdmin) {
            res.json(new ERR('无管理权限', 400));
            return;
        }


        //先判断是不是系统管理员或者产品管理员
        if (adminInfo.role.indexOf('admin') < 0) {//不是系统管理员

            if (!adminInfo.role.match('adm_' + par.app_sid)) { //不是相应产品的管理员
                res.json(new ERR('无产品权限', 400));
                return;
            }

            //是相应产品管理员
            if (par.role == 'admin') { //要添加的是产品管理员，则权限不够，只有系统管理员可添加
                res.json(new ERR('无系统权限', 400));
                return;
            }


        }

        //设置role + _app名 以区分
        if(par.role.indexOf('admin') >= 0){

            par.role = 'adm_' + par.app_sid;

        }else {

            var roleArr = par.role.split(',');
            for (var i=0; i<roleArr.length; i++) {
                roleArr[i] = roleArr[i] + "_" + par.app_sid;
            }
            par.role = roleArr.join();

        }
        console.log(par.role);

        //设置密码
        par.password = 'tao1024' + par.account + 'llc';
        var md5 = crypto.createHash('md5');
        md5.update(par.password);
        par.password = md5.digest('hex');

        ManagementDao.addAdmin(par, function(err , data){
            if(err) {
                res.json(new ERR(err, 400));
            } else {
                delete par.password;
                // delete par.purview_Id;
                res.json(new PKG(par));
            }
        });
    });
}
router.post('/addAdmin', ManagementRouter.addAdmin);

/**
 * 系统管理员修改产品管理员、产品管理员修改功能管理员； 可更改状态、资料，所属app,app权限
 * @param  token 操作员
 * @param  uid   被操作管理员的
 * @param  app_sid   被操作管理员的
 * @param  role   被操作管理员的
 *         url/admin_management/updateAdmin
 */
ManagementRouter.updateAdmin = function(req, res) {
    var par = paramAll(req);
    router.checkAdmin(par, function(err,errCode,handleAdmin) {
        if(err){
            res.json(new ERR(err, errCode));
            return;
        }
        if(!handleAdmin){//其他异常情况
            res.json(new ERR('服务器异常', 400));
            return;
        }

        //确定有权限操作被修改者，去修改
        var usersInfo = {};

        //剩余操作的情况:1、系统->自己，2、系统->产品，3、系统->功能，6.2、本产品->本产品的功能管理员

        //就只修改功能管理员权限
        if(par.role) {

            //如果该管理员无此app，说明肯定是系统管理员的操作，产品管理员已过滤. 因此无该app则加上
            if(handleAdmin.app_sid.indexOf(par.app_sid) < 0){
                res.json(new ERR('该管理员不可修改', 400));
                return;
            }

            if (par.role == 'admin') {//系统管理员操作产品管理员、功能；  将所有app下权限都删除，添加上admin权限;
                // var roleArr = [];
                // var oldRoleArr = handleAdmin.role.split(',');
                // for (var i = 0; i < oldRoleArr.length; i++) {//取出不带app的其他所有权限
                //     var roleStr = oldRoleArr[i];
                //     if (roleStr.indexOf(par.app_sid) < 0) {
                //         roleArr.push(roleStr);
                //     }
                // }
                // roleArr.push('adm_' + par.app_sid);
                // if(roleArr.length > 0){
                //     usersInfo.role = roleArr.join();
                // }

                res.json(new ERR('该管理员不可修改', 400));
                return;

            } else {//系统管理员操作产品管理员、功能管理员，产品管理员操作功能管理员

                if(handleAdmin.role.indexOf('adm_' + par.app_sid) >= 0){
                    res.json(new ERR('已有该产品全部权限', 400));
                    return;
                }

                var addRoleArr = par.role.split(',');
                var oldRoleArr = [];
                for (var i = 0; i < addRoleArr.length; i++) {
                    var roleStr = addRoleArr[i] + '_' + par.app_sid;
                    // if (handleAdmin.role.indexOf(roleStr) < 0) {//如果没有该权限，则添加
                        oldRoleArr.push(roleStr);
                    // }
                }

                if(oldRoleArr.length > 0) {
                    usersInfo.role = oldRoleArr.toString();
                }
            }

        }

        if(par.name) {
            usersInfo.name = par.name;
        }
        if(par.email){
            var myreg = /^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
            if(!myreg.test(par.email)){
                res.json(new ERR('参数格式有误', 400));
                return;
            }
            usersInfo.email = par.email;
        }

        var data = {};
        data.adminInfo = usersInfo;
        data.uid = par.uid;
        ManagementDao.updateAdmin(data, function(err , data){
            if(err) {
                res.json(new ERR(err, 400));
            } else {
                res.json(new PKG(data));
            }
        });

    });
}
router.post('/updateAdmin', ManagementRouter.updateAdmin);



/**
 * 系统管理员更改产品管理员、产品管理员修改功能管理员状态
 * @param  token 操作员
 * @param  uid   被操作管理员的
 * @param  account   被操作管理员的
 * @param  app_sid   被操作管理员的
 * @param  status 修改该里员的状态
 *         url/admin_management/updateAdmin
 */
ManagementRouter.updateAdminStatus = function(req, res) {
    var par = paramAll(req);
    if(!par.account){
        res.json(new ERR('管理员账号不为空', 400));
        return;
    }
    if(par.status != 1 && par.status != 0){
        res.json(new ERR('管理员状态参数有误', 400));
        return;
    }
    router.checkAdmin(par, function(err,errCode,handleAdmin) {
        if(err){
            res.json(new ERR(err, errCode));
            return;
        }
        if(!handleAdmin){//其他异常情况
            res.json(new ERR('服务器异常', 400));
            return;
        }

        //确定有权限操作被修改者，去修改

        //剩余操作的情况:1、系统->自己，2、系统->产品，3、系统->功能，6.2、本产品->本产品的功能管理员
        if (par.status) {
            if (par.status != 1 && par.status != 0) {
                res.json(new ERR('参数格式错误', 400));
                return;
            }
        }

        //判断被修改人是不是该产品的产品管理员
        par.isAppAdm = handleAdmin.role.indexOf('adm_' + par.app_sid) >= 0 ? true : false;

        ManagementDao.updateAdminStatus(par, function(err , data){
            if(err) {
                res.json(new ERR(err, 400));
            } else {
                res.json(new PKG(data));
            }
        });

    });
}
router.post('/updateAdminStatus', ManagementRouter.updateAdminStatus);


/**
 * 管理员删除管理员权限
 * @param  token 操作员
 * @param  uid   被操作管理员的
 * @param  app   被操作管理员的
 * @param  role   被操作管理员的
 *         url/admin_management/delAdminRole
 */
//暂时不提供该接口
// ManagementRouter.delAdminRole = function(req, res) {
//     var par = paramAll(req);
//     router.checkAdmin(par, function(err,errCode,handleAdmin,adminInfo) {
//         if(err){
//             res.json(new ERR(err, errCode));
//             return;
//         }
//         if(!handleAdmin){//其他异常情况
//             res.json(new ERR('服务器异常', 400));
//             return;
//         }
//
//         //再剔除一种产品管理员删除自己的权限的情况
//         if(handleAdmin.role.indexOf('adm_' + par.app_sid) >= 0 && adminInfo.role.indexOf('admin') < 0){
//             res.json(new ERR('无系统权限', 400));
//             return;
//         }
//
//         //确定有权限操作被修改者，去修改
//         var usersInfo = {};
//
//         //剩余操作的情况:1、系统->自己，2、系统->产品，3、系统->功能，6.2、本产品->本产品的功能管理员
//
//         if(par.role) {//产品管理员删除功能管理员权限 或者 系统管理员删除产品管理员、功能管理员权限
//
//             //删除该管理员该app下的相关role权限
//             var delRoleArr = par.role.split(',');
//             var oldRoleArr = handleAdmin.role.split(',');
//             var newRoleArr = [];
//             for(var i=0; i<oldRoleArr.length; i++){
//                 var oldStr = oldRoleArr[i];
//                 var j=0
//                 for(; j<delRoleArr.length; j++){//看原权限是否在要删除的权限中，不在则填上
//                     var delStr = delRoleArr[j] + '_' +par.app_sid;
//                     if(delStr == oldStr){
//                         break;
//                     }
//                 }
//                 if(j >= delRoleArr.length){
//                     newRoleArr.push(oldStr);
//                 }
//
//             }
//             usersInfo.role = newRoleArr.toString();
//
//         }else {//只有app 系统管理员能用，其他剔除
//
//             if(adminInfo.role.indexOf('admin') < 0){
//                 res.json(new ERR('无系统权限', 400));
//                 return;
//             }
//
//             //删除该管理员所有相关app的role权限
//             var newRoleArr = [];
//             var oldRoleArr = handleAdmin.role.split(',');
//             for(var i=0; i<oldRoleArr.length; i++){
//                 var roleStr = oldRoleArr[i];
//                 if(roleStr.indexOf('_'+par.app_sid) < 0){//如果不是该app下的权限，添加进来
//                     newRoleArr.push(roleStr);
//                 }
//             }
//             usersInfo.role = newRoleArr.toString();
//
//         }
//
//         if(!par.role || par.role == 'admin'){//如果只传app或者删除的role是admin权限,则删除对应app
//             //删除该管理员的对应app
//             var newAppArr = [];
//             var oldAppArr = handleAdmin.app_sid.split(',');
//             for(var i=0; i<oldAppArr.length; i++){
//                 var appStr = oldAppArr[i];
//                 if(appStr.indexOf(par.app_sid) < 0){//如果不是该app下的权限，添加进来
//                     newAppArr.push(appStr);
//                 }
//             }
//             usersInfo.app_sid = newAppArr.toString();
//         }
//
//
//         var data = {};
//         data.adminInfo = usersInfo;
//         data.uid = par.uid;
//         ManagementDao.updateAdmin(data, function(err , data){
//             if(err) {
//                 res.json(new ERR(err, 400));
//             } else {
//                 res.json(new PKG(data));
//             }
//         });
//
//     });
// }
// router.post('/delAdminRole', ManagementRouter.delAdminRole);


/**
 * 验证管理员操作权限抽取
 * 除操作人、被操作人不存在外，其他权限共有9大类12种情况：
 * 1、系统->自己 2、系统->产品 3、系统->功能
 * 4、产品->系统
 * 5、产品->产品 (细分：  5.1、产品->产品管理员(包括本产品及其他产品)  5.2、产品->操作产品权限）
 * 6、产品->功能 (细分：  6.1、本产品->其他功能  6.2、本产品->本产品功能   6.3、其他产品->功能)
 * 7、功能->系统  8、功能->产品 9、功能->功能
 * 允许操作的情况:1、系统->自己，2、系统->产品，3、系统->功能，6.2、本产品->本产品功能
 */
router.checkAdmin = function (par,callback) {

    AdminToken.checkLogin(par.token, function (err, adminInfo) {
        if(err) {
            callback(err,400,adminInfo);
            return;
        }
        //验证管理员身份
        if(!adminInfo){
            callback('请先登录',403);
            return ;
        }
        if(!adminInfo.isAdmin) {
            callback('无权限',400);
            return ;
        }

        //验证被操作管理员的信息参数是否完整
        if(!par.uid){
            callback('uid 不为空',400);
            return;
        }
        if(!par.app_sid){
            callback('app_sid 不为空！',400);
            return;
        }

        //操作人不是该产品管理员且不是系统管理员  过滤第6.3、7、8、9  四种情况
        if(adminInfo.role.indexOf('adm_' + par.app_sid) < 0 && adminInfo.role.indexOf('admin') < 0){
            callback('无权限访问',400);
            return;
        }

        //通过uid查找被操作管理员，进一步验证被管理员身份
        ManagementDao.findAdmin(par.uid,function (err,handleAdmin) {

            if(err){
                callback(err,400);
                return;
            }

            if(!handleAdmin){//被操作人不存在
                callback('该管理员不存在',400);
                return;
            }

            if(adminInfo.role.indexOf('admin') < 0){//操作人不是系统管理员，则操作人是产品管理员（功能管理员已过滤）

                if(handleAdmin.app_sid.indexOf(par.app_sid) < 0){//被操作人不属于该产品  过滤第6.1 一种情况
                    callback('该管理员无产品权限',400);
                    return;
                }

                if(handleAdmin.role.indexOf('admin') >= 0) {//被操作人是系统管理员  过滤第4 一种情况
                    callback('无系统权限',400);
                    return;
                }

                //被操作人是产品管理员，则权限不够，只有系统管理员可修改  过滤第5.1 一种情况
                if (handleAdmin.role.indexOf('adm_' + par.app_sid) >= 0) {
                    callback('无系统权限',400);
                    return;
                }

                //被操作人要操作产品的权限  过滤第5.2 一种情况
                if(par.role && par.role == 'admin'){
                    callback('无系统权限',400);
                    return;
                }
            }

            //确定有权限操作被修改者，去修改
            //允许操作的情况:1、系统->自己，2、系统->产品，3、系统->功能，6.2、本产品->本产品的功能管理员
            callback(null,0,handleAdmin,adminInfo);

        });

    });
}


/**
 * 系统管理员、产品管理员查询相应产品管理员列表
 * @param  token
 *         url/admin_management/findAdminList
 */
ManagementRouter.findAdminList = function(req, res) {
    var par = paramAll(req);
    AdminToken.checkLogin(par.token, function (err, adminInfo) {
        if(err) {
            return;
        }
        //验证管理员权限
        if(!adminInfo){
            res.json(new ERR('请先登录', 403));
            return ;
        }
        if(!adminInfo.isAdmin) {
            res.json(new ERR('无权限', 400));
            return ;
        }

        //操作人不是该产品管理员且不是系统管理员
        if(adminInfo.role.indexOf('adm_' + par.app_sid) < 0 && adminInfo.role.indexOf('admin') < 0){
            res.json(new ERR('无权限访问', 400));
            return;
        }

        var searchInfo = {};
        if(par.app_sid) searchInfo.app_sid = par.app_sid;
        if(par.name) searchInfo.name = par.name;
        if(par.uid) searchInfo.uid = par.uid;
        if(par.phoneTail) {
            if(par.phoneTail.length != 4 || isNaN(par.phoneTail)){
                res.json(new ERR('手机尾号有误', 400));
                return;
            }
            searchInfo.phoneTail = par.phoneTail;
        }
        ManagementDao.findAdminList(searchInfo,function (err,result) {
            if (err) {
                console.log(err);
                return;
            }
            if (result.admins[0]) {
                res.json(new PKG(result));
            } else {
                res.json(new ERR('该管理员不存在', 400));
            }

        });

    });
}
router.post('/findAdminList', ManagementRouter.findAdminList);

module.exports = router;
